task_ini = ini_file("misc\\task\\task_manager.ltx")
local random_task = nil

class "CRandomTask"
function CRandomTask:__init()
	--' Таблица проинициализированных квестов.
	self.task_info = {}
end
-- Save
function CRandomTask:save(packet)
	if (USE_MARSHAL) then 
		return 
	end 
	
	set_save_marker(packet, "save", false, "CRandomTask")
	local n = 0
	for k,v in pairs(self.task_info) do
		n = n + 1
	end
	packet:w_u16(n)
	for k,v in pairs(self.task_info) do
		packet:w_stringZ(k)
		self.task_info[k]:save(packet)
	end

	set_save_marker(packet, "save", true, "CRandomTask")
end
-- Load
function CRandomTask:load(reader)
	if (USE_MARSHAL) then 
		return 
	end 
	
	set_save_marker(reader, "load", false, "CRandomTask")

	local n = reader:r_u16()
	for i=1,n do
		local id = reader:r_stringZ()
		printf("task_manager: loaded %s",id)
		local obj = task_objects.CGeneralTask(id)
		obj:load(reader)
		self.task_info[id] = obj
	end

	set_save_marker(reader, "load", true, "CRandomTask")
end
--------------------------------------------------------------------------------

--' Выдача квеста игроку
function CRandomTask:give_task(task_id,task_giver_id)
	printf("CRandomTask:give_task() task_id[%s]", tostring(task_id))
	printf("giver_id %s", tostring(task_giver_id))
	--if (npc:id() == task_info[task_id].task_giver_id) then
		--printf("%s == %s", tostring(npc:id), tostring(task_info[task_id].task_giver_id))

	if not task_ini:section_exist(task_id) then
		printe("!ERROR There is no task [%s] in task ini_file or ini_file is not included!!!", task_id)
		return
	end
	
	if (self.task_info[task_id]) then 
		printf("task_manager: ERROR: TASK ALREADY EXISTS!!!")
	end
	
	if (USE_MARSHAL) then 
		local m_data = alife_storage_manager.get_state()
		if (m_data.task_objects and m_data.task_objects[task_id]) then
			printf("task_manager: WARNING: task data already existed for %s",task_id)
			m_data.task_objects[task_id] = nil
		end
		
		self.task_info[task_id] = task_objects.CGeneralTask(task_id)
		self.task_info[task_id]:give_task()
		self.task_info[task_id].task_giver_id = task_giver_id
		
		--self.task_info[task_id]:save_state(m_data)
		return
	end
	
	self.task_info[task_id] = task_objects.CGeneralTask(task_id)
	self.task_info[task_id]:give_task()
	self.task_info[task_id].task_giver_id = task_giver_id
end

function CRandomTask:set_task_completed(task_id)
	if (self.task_info[task_id]) then 
		self.task_info[task_id].forced_status = "complete"
	end
end

function CRandomTask:set_task_failed(task_id)
	if (self.task_info[task_id]) then 
		self.task_info[task_id].forced_status = "fail"
	end
end

function CRandomTask:set_task_cancelled(task_id)
    if (self.task_info[task_id]) then
		self.task_info[task_id].forced_status = "fail"
		self.task_info[task_id].cancelled_by_actor = true
    end
end

function CRandomTask:update()
	--utils_data.debug_write("CRandomTask:update() - START")
	for k,v in pairs(self.task_info) do
		local tsk = self.task_info[k]
		tsk:check_task()
		if (tsk.timeout and game.get_game_time():diffSec(tsk.timeout) > tsk.repeat_timeout) then
			if (ui_options.get("alife/dynamic_news/nearby_activity_news")) then
				dynamic_news_manager.get_dynamic_news():GossipTaskRepeatTimeout(k)
			end
			if not (db.actor:get_task(k,true)) then -- don't remove if engine task object still exist
				self.task_info[k] = nil
			end
		end
	end
	--utils_data.debug_write("CRandomTask:update() - END")
end 

--' Проверяем, не выполнен ли таск
function CRandomTask:task_complete(p1)
	if (db.actor == nil or device().precache_frame > 1) then 
		return false 
	end 
	
	local tsk = self.task_info[p1]
	if tsk == nil then
		printe("!ERROR: CRandomTask:task_complete %s task is nil!",p1)
		return true
	end
	
	if (tsk.forced_status == "complete") then
		tsk.forced_status = nil
		tsk.last_check_task = "complete"
	elseif (tsk.forced_status == "fail") then 
		return false
	end
	
	if tsk.last_check_task == "complete" then
		return true
	end
	return false
end
--' Проверяем, не профейлен ли таск
function CRandomTask:task_fail(p1)
	if (db.actor == nil or device().precache_frame > 1) then 
		return false 
	end 
	
	local tsk = self.task_info[p1]
	if tsk == nil then
		printe("!ERROR: CRandomTask:task_fail %s task is nil!",p1)
		return false
	end
	
	if (tsk.forced_status == "fail") then
		tsk.forced_status = nil
		tsk.last_check_task = "fail"
	elseif (tsk.forced_status == "complete") then 
		return false
	end
	
	if (tsk.last_check_task == "fail") then
		return true
	end
	return false
end

function get_task_manager()
	if random_task == nil then
		random_task = CRandomTask()
	end
	return random_task
end

function task_complete(p1)
	return get_task_manager():task_complete(p1)
end
function task_fail(p1)
	return get_task_manager():task_fail(p1)
end
function task_callback(tsk, state)
	local tm = get_task_manager()
	local id = tsk:get_id()
	
	local rtask = tm.task_info[id]
	if not (rtask) then
		return 
	end 
	
	local giver_npc_id = rtask.task_giver_id -- mlr
	
	--printf("task_callback %s state=%s",id,state == task.fail and "fail" or state == task.completed and "complete" or state)
	if (state == task.fail) then
		news_manager.send_task(db.actor, "fail", tsk)
		
		rtask.status = "fail"
		
		if (rtask.cancelled_by_actor) then
			game_statistics.increment_statistic("tasks_cancelled")
			if (rtask.on_cancel) then
				xr_logic.pick_section_from_condlist(db.actor, db.actor, rtask.on_cancel)
				save_var(db.actor,id,nil) -- Tronex: reset saved data
			end

		else
			game_statistics.increment_statistic("tasks_failed")
			if (rtask.on_fail) then
				xr_logic.pick_section_from_condlist(db.actor, db.actor, rtask.on_fail)
				save_var(db.actor,id,nil) -- Tronex: reset saved data
			end
		end
		
		if (rtask.repeat_timeout) then
			rtask.cancelled_by_actor = nil
			rtask.forced_status = nil
			rtask.t = nil
			rtask.timeout = game.get_game_time()
			rtask.stage = 255
		else
			tm.task_info[id] = nil
		end
	elseif (state == task.completed) then 
		if (rtask.on_complete) then
			xr_logic.pick_section_from_condlist(db.actor, db.actor, rtask.on_complete)
			save_var(db.actor,id,nil) -- Tronex: reset saved data
		end
		rtask:give_reward()
		rtask.status = "completed"
		game_statistics.increment_statistic("tasks_completed")
		
		-- Toolkits reward progress
		local cnt = load_var(db.actor, "toolkit_reward_count") or 0
		save_var(db.actor, "toolkit_reward_count", cnt + 1)
		--printf("task_manager | toolkit_reward_count: %s", cnt + 1)
		
		if (rtask.repeat_timeout) then
			rtask.cancelled_by_actor = nil
			rtask.forced_status = nil
			rtask.t = nil
			rtask.timeout = game.get_game_time()
			rtask.stage = 255
		else 
			tm.task_info[id] = nil
		end
	end
end

function clear_task_manager()
end


--====================================================
function save_state(m_data)
	--utils_data.debug_write("task_manager.save_state")
	m_data.task_info = not m_data.task_info and {} or empty_table(m_data.task_info)
	m_data.task_objects = not m_data.task_objects and {} or empty_table(m_data.task_objects)
	
	local tm = get_task_manager()
	
	for k,v in pairs(tm.task_info) do
		m_data.task_info[k] = true
		tm.task_info[k]:save_state(m_data)
	end
end 

function load_state(m_data)
	if not (m_data.task_info) then 
		return 
	end 
	
	local tm = get_task_manager()
	
	for task_id,v in pairs(m_data.task_info) do 
		local obj = task_objects.CGeneralTask(task_id)
		if (obj:load_state(m_data) == true) then
			tm.task_info[task_id] = obj
			--[[
			local t = db.actor and db.actor:get_task(obj.id,true)
			if (t) then
				t:add_complete_func("task_manager.task_complete")
				t:add_fail_func("task_manager.task_fail")
			end
			--]]
		end
	end
	
	m_data.task_info = nil
end